// Generated from BitQV2.g4 by ANTLR 4.7.2

	package com.xuanyue.db.xuan.antlr.v2;

import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class BitQV2Parser extends Parser {
	static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, SELECT=7, FROM=8, ON=9, 
		LEFT=10, RIGHT=11, JOIN=12, WHERE=13, AND=14, OR=15, NOT=16, ExprNot=17, 
		FUNCTION=18, Order=19, By=20, DESC=21, ASC=22, MIX=23, PLUS=24, REDUCE=25, 
		STRING=26, NUM=27, TRUE=28, FALSE=29, NULL=30, TO_DATE=31, TransArrt=32, 
		Phone_seach=33, PositionMatch=34, Contains=35, Has_Every_Char=36, STARTSWITH=37, 
		ENDSWITH=38, INSERT=39, INTO=40, VALUES=41, SAVE=42, AS=43, UPDATE=44, 
		SET=45, DELETE=46, LIMIT=47, CREATE=48, ALTER=49, DROP=50, ADD=51, SOURCE=52, 
		DATABASE=53, TABLE=54, PHONE=55, LONG=56, INT=57, DATE=58, FLOAT=59, BOOLEAN=60, 
		UFLOAT=61, UINT=62, ULONG=63, LIST=64, MAP=65, MAPBOOLEAN=66, MAPUNUMBER=67, 
		COMMA=68, SEMI=69, NAME=70, DOT=71, ARRAY_L=72, ARRAY_R=73, Brackets_L=74, 
		Brackets_R=75, COLON=76, WS=77, SQL_COMMENT=78;
	public static final int
		RULE_bitQ = 0, RULE_fields = 1, RULE_fullName = 2, RULE_phone_seach = 3, 
		RULE_orNot = 4, RULE_andNot = 5, RULE_orCondition = 6, RULE_andCondition = 7, 
		RULE_conditionElement = 8, RULE_groupCondition = 9, RULE_boolTF = 10, 
		RULE_values = 11, RULE_to_date = 12, RULE_array = 13, RULE_exprValue = 14, 
		RULE_arrayIndex0 = 15, RULE_arrayIndex1 = 16, RULE_arrayIndex2 = 17, RULE_arrayIndex3 = 18, 
		RULE_arrayIndex4 = 19, RULE_arrayIndex = 20, RULE_exprKey = 21, RULE_function = 22, 
		RULE_baseExpr = 23, RULE_conditionExpr = 24, RULE_query = 25, RULE_result = 26, 
		RULE_repo = 27, RULE_sortBy = 28, RULE_sortE = 29, RULE_mix = 30, RULE_limit = 31, 
		RULE_saveAsFile = 32, RULE_insertInto = 33, RULE_setValue = 34, RULE_update = 35, 
		RULE_delete = 36, RULE_setSource = 37, RULE_createTable = 38, RULE_column = 39, 
		RULE_cType = 40, RULE_intType = 41, RULE_uintType = 42, RULE_dateType = 43, 
		RULE_floatType = 44, RULE_ufloatType = 45, RULE_booleanType = 46, RULE_longType = 47, 
		RULE_ulongType = 48, RULE_phoneType = 49, RULE_listType = 50, RULE_mapType = 51, 
		RULE_alertTable = 52, RULE_alertOP = 53;
	private static String[] makeRuleNames() {
		return new String[] {
			"bitQ", "fields", "fullName", "phone_seach", "orNot", "andNot", "orCondition", 
			"andCondition", "conditionElement", "groupCondition", "boolTF", "values", 
			"to_date", "array", "exprValue", "arrayIndex0", "arrayIndex1", "arrayIndex2", 
			"arrayIndex3", "arrayIndex4", "arrayIndex", "exprKey", "function", "baseExpr", 
			"conditionExpr", "query", "result", "repo", "sortBy", "sortE", "mix", 
			"limit", "saveAsFile", "insertInto", "setValue", "update", "delete", 
			"setSource", "createTable", "column", "cType", "intType", "uintType", 
			"dateType", "floatType", "ufloatType", "booleanType", "longType", "ulongType", 
			"phoneType", "listType", "mapType", "alertTable", "alertOP"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'='", "'!='", "'>='", "'>'", "'<='", "'<'", null, null, null, 
			null, null, null, null, null, null, null, "'!'", null, null, null, null, 
			null, null, "'+'", "'-'", null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, "','", "';'", 
			null, "'.'", "'['", "']'", "'('", "')'", "':'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, null, null, null, null, null, null, "SELECT", "FROM", "ON", "LEFT", 
			"RIGHT", "JOIN", "WHERE", "AND", "OR", "NOT", "ExprNot", "FUNCTION", 
			"Order", "By", "DESC", "ASC", "MIX", "PLUS", "REDUCE", "STRING", "NUM", 
			"TRUE", "FALSE", "NULL", "TO_DATE", "TransArrt", "Phone_seach", "PositionMatch", 
			"Contains", "Has_Every_Char", "STARTSWITH", "ENDSWITH", "INSERT", "INTO", 
			"VALUES", "SAVE", "AS", "UPDATE", "SET", "DELETE", "LIMIT", "CREATE", 
			"ALTER", "DROP", "ADD", "SOURCE", "DATABASE", "TABLE", "PHONE", "LONG", 
			"INT", "DATE", "FLOAT", "BOOLEAN", "UFLOAT", "UINT", "ULONG", "LIST", 
			"MAP", "MAPBOOLEAN", "MAPUNUMBER", "COMMA", "SEMI", "NAME", "DOT", "ARRAY_L", 
			"ARRAY_R", "Brackets_L", "Brackets_R", "COLON", "WS", "SQL_COMMENT"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "BitQV2.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }


	@Override
	public Token match(int ttype) throws RecognitionException {
		Token t = getCurrentToken();
		if ( t.getType()==ttype ) {
			if ( ttype==Token.EOF ) {
				matchedEOF = true;
			}
			_errHandler.reportMatch(this);
			consume();
			return t;
		}
		else {
			throw new RuntimeException("miss "+ _SYMBOLIC_NAMES[ttype]);
		}
		
	}

	public BitQV2Parser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	public static class BitQContext extends ParserRuleContext {
		public QueryContext query() {
			return getRuleContext(QueryContext.class,0);
		}
		public InsertIntoContext insertInto() {
			return getRuleContext(InsertIntoContext.class,0);
		}
		public UpdateContext update() {
			return getRuleContext(UpdateContext.class,0);
		}
		public DeleteContext delete() {
			return getRuleContext(DeleteContext.class,0);
		}
		public AlertTableContext alertTable() {
			return getRuleContext(AlertTableContext.class,0);
		}
		public CreateTableContext createTable() {
			return getRuleContext(CreateTableContext.class,0);
		}
		public BitQContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bitQ; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterBitQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitBitQ(this);
		}
	}

	public final BitQContext bitQ() throws RecognitionException {
		BitQContext _localctx = new BitQContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_bitQ);
		try {
			setState(114);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case SELECT:
				enterOuterAlt(_localctx, 1);
				{
				setState(108);
				query();
				}
				break;
			case INSERT:
				enterOuterAlt(_localctx, 2);
				{
				setState(109);
				insertInto();
				}
				break;
			case UPDATE:
				enterOuterAlt(_localctx, 3);
				{
				setState(110);
				update();
				}
				break;
			case DELETE:
				enterOuterAlt(_localctx, 4);
				{
				setState(111);
				delete();
				}
				break;
			case ALTER:
				enterOuterAlt(_localctx, 5);
				{
				setState(112);
				alertTable();
				}
				break;
			case CREATE:
				enterOuterAlt(_localctx, 6);
				{
				setState(113);
				createTable();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FieldsContext extends ParserRuleContext {
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public List<TerminalNode> NAME() { return getTokens(BitQV2Parser.NAME); }
		public TerminalNode NAME(int i) {
			return getToken(BitQV2Parser.NAME, i);
		}
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public FieldsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fields; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterFields(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitFields(this);
		}
	}

	public final FieldsContext fields() throws RecognitionException {
		FieldsContext _localctx = new FieldsContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_fields);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(116);
			match(Brackets_L);
			setState(117);
			match(NAME);
			setState(122);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(118);
				match(COMMA);
				setState(119);
				match(NAME);
				}
				}
				setState(124);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(125);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FullNameContext extends ParserRuleContext {
		public List<TerminalNode> NAME() { return getTokens(BitQV2Parser.NAME); }
		public TerminalNode NAME(int i) {
			return getToken(BitQV2Parser.NAME, i);
		}
		public List<TerminalNode> DOT() { return getTokens(BitQV2Parser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(BitQV2Parser.DOT, i);
		}
		public FullNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fullName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterFullName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitFullName(this);
		}
	}

	public final FullNameContext fullName() throws RecognitionException {
		FullNameContext _localctx = new FullNameContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_fullName);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(127);
			match(NAME);
			setState(132);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DOT) {
				{
				{
				setState(128);
				match(DOT);
				setState(129);
				match(NAME);
				}
				}
				setState(134);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Phone_seachContext extends ParserRuleContext {
		public Token op;
		public TerminalNode Phone_seach() { return getToken(BitQV2Parser.Phone_seach, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public FullNameContext fullName() {
			return getRuleContext(FullNameContext.class,0);
		}
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public TerminalNode STRING() { return getToken(BitQV2Parser.STRING, 0); }
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public TerminalNode PositionMatch() { return getToken(BitQV2Parser.PositionMatch, 0); }
		public TerminalNode Contains() { return getToken(BitQV2Parser.Contains, 0); }
		public TerminalNode Has_Every_Char() { return getToken(BitQV2Parser.Has_Every_Char, 0); }
		public Phone_seachContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_phone_seach; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterPhone_seach(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitPhone_seach(this);
		}
	}

	public final Phone_seachContext phone_seach() throws RecognitionException {
		Phone_seachContext _localctx = new Phone_seachContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_phone_seach);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(135);
			match(Phone_seach);
			setState(136);
			match(Brackets_L);
			setState(137);
			fullName();
			setState(138);
			match(COMMA);
			setState(139);
			((Phone_seachContext)_localctx).op = _input.LT(1);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PositionMatch) | (1L << Contains) | (1L << Has_Every_Char))) != 0)) ) {
				((Phone_seachContext)_localctx).op = (Token)_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(140);
			match(COMMA);
			setState(141);
			match(STRING);
			setState(142);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OrNotContext extends ParserRuleContext {
		public TerminalNode OR() { return getToken(BitQV2Parser.OR, 0); }
		public TerminalNode NOT() { return getToken(BitQV2Parser.NOT, 0); }
		public OrNotContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_orNot; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterOrNot(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitOrNot(this);
		}
	}

	public final OrNotContext orNot() throws RecognitionException {
		OrNotContext _localctx = new OrNotContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_orNot);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(144);
			match(OR);
			setState(146);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==NOT) {
				{
				setState(145);
				match(NOT);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AndNotContext extends ParserRuleContext {
		public TerminalNode AND() { return getToken(BitQV2Parser.AND, 0); }
		public TerminalNode NOT() { return getToken(BitQV2Parser.NOT, 0); }
		public AndNotContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_andNot; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterAndNot(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitAndNot(this);
		}
	}

	public final AndNotContext andNot() throws RecognitionException {
		AndNotContext _localctx = new AndNotContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_andNot);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(148);
			match(AND);
			setState(150);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==NOT) {
				{
				setState(149);
				match(NOT);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OrConditionContext extends ParserRuleContext {
		public OrNotContext operator;
		public List<AndConditionContext> andCondition() {
			return getRuleContexts(AndConditionContext.class);
		}
		public AndConditionContext andCondition(int i) {
			return getRuleContext(AndConditionContext.class,i);
		}
		public TerminalNode NOT() { return getToken(BitQV2Parser.NOT, 0); }
		public List<OrNotContext> orNot() {
			return getRuleContexts(OrNotContext.class);
		}
		public OrNotContext orNot(int i) {
			return getRuleContext(OrNotContext.class,i);
		}
		public OrConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_orCondition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterOrCondition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitOrCondition(this);
		}
	}

	public final OrConditionContext orCondition() throws RecognitionException {
		OrConditionContext _localctx = new OrConditionContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_orCondition);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(153);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==NOT) {
				{
				setState(152);
				match(NOT);
				}
			}

			setState(155);
			andCondition();
			setState(161);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==OR) {
				{
				{
				setState(156);
				((OrConditionContext)_localctx).operator = orNot();
				setState(157);
				andCondition();
				}
				}
				setState(163);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AndConditionContext extends ParserRuleContext {
		public AndNotContext operator;
		public List<ConditionElementContext> conditionElement() {
			return getRuleContexts(ConditionElementContext.class);
		}
		public ConditionElementContext conditionElement(int i) {
			return getRuleContext(ConditionElementContext.class,i);
		}
		public List<AndNotContext> andNot() {
			return getRuleContexts(AndNotContext.class);
		}
		public AndNotContext andNot(int i) {
			return getRuleContext(AndNotContext.class,i);
		}
		public AndConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_andCondition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterAndCondition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitAndCondition(this);
		}
	}

	public final AndConditionContext andCondition() throws RecognitionException {
		AndConditionContext _localctx = new AndConditionContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_andCondition);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(164);
			conditionElement();
			setState(170);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==AND) {
				{
				{
				setState(165);
				((AndConditionContext)_localctx).operator = andNot();
				setState(166);
				conditionElement();
				}
				}
				setState(172);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConditionElementContext extends ParserRuleContext {
		public GroupConditionContext groupCondition() {
			return getRuleContext(GroupConditionContext.class,0);
		}
		public ConditionExprContext conditionExpr() {
			return getRuleContext(ConditionExprContext.class,0);
		}
		public ConditionElementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conditionElement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterConditionElement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitConditionElement(this);
		}
	}

	public final ConditionElementContext conditionElement() throws RecognitionException {
		ConditionElementContext _localctx = new ConditionElementContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_conditionElement);
		try {
			setState(175);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Brackets_L:
				enterOuterAlt(_localctx, 1);
				{
				setState(173);
				groupCondition();
				}
				break;
			case FUNCTION:
			case NAME:
				enterOuterAlt(_localctx, 2);
				{
				setState(174);
				conditionExpr();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GroupConditionContext extends ParserRuleContext {
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public OrConditionContext orCondition() {
			return getRuleContext(OrConditionContext.class,0);
		}
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public GroupConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_groupCondition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterGroupCondition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitGroupCondition(this);
		}
	}

	public final GroupConditionContext groupCondition() throws RecognitionException {
		GroupConditionContext _localctx = new GroupConditionContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_groupCondition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(177);
			match(Brackets_L);
			setState(178);
			orCondition();
			setState(179);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BoolTFContext extends ParserRuleContext {
		public TerminalNode TRUE() { return getToken(BitQV2Parser.TRUE, 0); }
		public TerminalNode FALSE() { return getToken(BitQV2Parser.FALSE, 0); }
		public BoolTFContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_boolTF; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterBoolTF(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitBoolTF(this);
		}
	}

	public final BoolTFContext boolTF() throws RecognitionException {
		BoolTFContext _localctx = new BoolTFContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_boolTF);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(181);
			_la = _input.LA(1);
			if ( !(_la==TRUE || _la==FALSE) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ValuesContext extends ParserRuleContext {
		public To_dateContext to_date() {
			return getRuleContext(To_dateContext.class,0);
		}
		public TerminalNode STRING() { return getToken(BitQV2Parser.STRING, 0); }
		public TerminalNode NUM() { return getToken(BitQV2Parser.NUM, 0); }
		public BoolTFContext boolTF() {
			return getRuleContext(BoolTFContext.class,0);
		}
		public TerminalNode TransArrt() { return getToken(BitQV2Parser.TransArrt, 0); }
		public TerminalNode NULL() { return getToken(BitQV2Parser.NULL, 0); }
		public ValuesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_values; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterValues(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitValues(this);
		}
	}

	public final ValuesContext values() throws RecognitionException {
		ValuesContext _localctx = new ValuesContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_values);
		try {
			setState(189);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case TO_DATE:
				enterOuterAlt(_localctx, 1);
				{
				setState(183);
				to_date();
				}
				break;
			case STRING:
				enterOuterAlt(_localctx, 2);
				{
				setState(184);
				match(STRING);
				}
				break;
			case NUM:
				enterOuterAlt(_localctx, 3);
				{
				setState(185);
				match(NUM);
				}
				break;
			case TRUE:
			case FALSE:
				enterOuterAlt(_localctx, 4);
				{
				setState(186);
				boolTF();
				}
				break;
			case TransArrt:
				enterOuterAlt(_localctx, 5);
				{
				setState(187);
				match(TransArrt);
				}
				break;
			case NULL:
				enterOuterAlt(_localctx, 6);
				{
				setState(188);
				match(NULL);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class To_dateContext extends ParserRuleContext {
		public TerminalNode TO_DATE() { return getToken(BitQV2Parser.TO_DATE, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public List<TerminalNode> STRING() { return getTokens(BitQV2Parser.STRING); }
		public TerminalNode STRING(int i) {
			return getToken(BitQV2Parser.STRING, i);
		}
		public TerminalNode COMMA() { return getToken(BitQV2Parser.COMMA, 0); }
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public To_dateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_to_date; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterTo_date(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitTo_date(this);
		}
	}

	public final To_dateContext to_date() throws RecognitionException {
		To_dateContext _localctx = new To_dateContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_to_date);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(191);
			match(TO_DATE);
			setState(192);
			match(Brackets_L);
			setState(193);
			match(STRING);
			setState(194);
			match(COMMA);
			setState(195);
			match(STRING);
			setState(196);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrayContext extends ParserRuleContext {
		public TerminalNode ARRAY_L() { return getToken(BitQV2Parser.ARRAY_L, 0); }
		public List<ValuesContext> values() {
			return getRuleContexts(ValuesContext.class);
		}
		public ValuesContext values(int i) {
			return getRuleContext(ValuesContext.class,i);
		}
		public TerminalNode ARRAY_R() { return getToken(BitQV2Parser.ARRAY_R, 0); }
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public ArrayContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_array; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterArray(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitArray(this);
		}
	}

	public final ArrayContext array() throws RecognitionException {
		ArrayContext _localctx = new ArrayContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_array);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(198);
			match(ARRAY_L);
			setState(199);
			values();
			setState(204);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(200);
				match(COMMA);
				setState(201);
				values();
				}
				}
				setState(206);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(207);
			match(ARRAY_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExprValueContext extends ParserRuleContext {
		public ValuesContext values() {
			return getRuleContext(ValuesContext.class,0);
		}
		public ArrayContext array() {
			return getRuleContext(ArrayContext.class,0);
		}
		public ExprValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exprValue; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterExprValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitExprValue(this);
		}
	}

	public final ExprValueContext exprValue() throws RecognitionException {
		ExprValueContext _localctx = new ExprValueContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_exprValue);
		try {
			setState(211);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case STRING:
			case NUM:
			case TRUE:
			case FALSE:
			case NULL:
			case TO_DATE:
			case TransArrt:
				enterOuterAlt(_localctx, 1);
				{
				setState(209);
				values();
				}
				break;
			case ARRAY_L:
				enterOuterAlt(_localctx, 2);
				{
				setState(210);
				array();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrayIndex0Context extends ParserRuleContext {
		public TerminalNode NUM() { return getToken(BitQV2Parser.NUM, 0); }
		public ArrayIndex0Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arrayIndex0; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterArrayIndex0(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitArrayIndex0(this);
		}
	}

	public final ArrayIndex0Context arrayIndex0() throws RecognitionException {
		ArrayIndex0Context _localctx = new ArrayIndex0Context(_ctx, getState());
		enterRule(_localctx, 30, RULE_arrayIndex0);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(213);
			match(NUM);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrayIndex1Context extends ParserRuleContext {
		public List<TerminalNode> NUM() { return getTokens(BitQV2Parser.NUM); }
		public TerminalNode NUM(int i) {
			return getToken(BitQV2Parser.NUM, i);
		}
		public TerminalNode COLON() { return getToken(BitQV2Parser.COLON, 0); }
		public ArrayIndex1Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arrayIndex1; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterArrayIndex1(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitArrayIndex1(this);
		}
	}

	public final ArrayIndex1Context arrayIndex1() throws RecognitionException {
		ArrayIndex1Context _localctx = new ArrayIndex1Context(_ctx, getState());
		enterRule(_localctx, 32, RULE_arrayIndex1);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(215);
			match(NUM);
			setState(216);
			match(COLON);
			setState(217);
			match(NUM);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrayIndex2Context extends ParserRuleContext {
		public TerminalNode NUM() { return getToken(BitQV2Parser.NUM, 0); }
		public TerminalNode COLON() { return getToken(BitQV2Parser.COLON, 0); }
		public ArrayIndex2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arrayIndex2; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterArrayIndex2(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitArrayIndex2(this);
		}
	}

	public final ArrayIndex2Context arrayIndex2() throws RecognitionException {
		ArrayIndex2Context _localctx = new ArrayIndex2Context(_ctx, getState());
		enterRule(_localctx, 34, RULE_arrayIndex2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(219);
			match(NUM);
			setState(220);
			match(COLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrayIndex3Context extends ParserRuleContext {
		public TerminalNode COLON() { return getToken(BitQV2Parser.COLON, 0); }
		public TerminalNode NUM() { return getToken(BitQV2Parser.NUM, 0); }
		public ArrayIndex3Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arrayIndex3; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterArrayIndex3(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitArrayIndex3(this);
		}
	}

	public final ArrayIndex3Context arrayIndex3() throws RecognitionException {
		ArrayIndex3Context _localctx = new ArrayIndex3Context(_ctx, getState());
		enterRule(_localctx, 36, RULE_arrayIndex3);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(222);
			match(COLON);
			setState(223);
			match(NUM);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrayIndex4Context extends ParserRuleContext {
		public TerminalNode COLON() { return getToken(BitQV2Parser.COLON, 0); }
		public ArrayIndex4Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arrayIndex4; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterArrayIndex4(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitArrayIndex4(this);
		}
	}

	public final ArrayIndex4Context arrayIndex4() throws RecognitionException {
		ArrayIndex4Context _localctx = new ArrayIndex4Context(_ctx, getState());
		enterRule(_localctx, 38, RULE_arrayIndex4);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(225);
			match(COLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrayIndexContext extends ParserRuleContext {
		public ArrayIndex0Context arrayIndex0() {
			return getRuleContext(ArrayIndex0Context.class,0);
		}
		public ArrayIndex1Context arrayIndex1() {
			return getRuleContext(ArrayIndex1Context.class,0);
		}
		public ArrayIndex2Context arrayIndex2() {
			return getRuleContext(ArrayIndex2Context.class,0);
		}
		public ArrayIndex3Context arrayIndex3() {
			return getRuleContext(ArrayIndex3Context.class,0);
		}
		public ArrayIndex4Context arrayIndex4() {
			return getRuleContext(ArrayIndex4Context.class,0);
		}
		public ArrayIndexContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arrayIndex; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterArrayIndex(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitArrayIndex(this);
		}
	}

	public final ArrayIndexContext arrayIndex() throws RecognitionException {
		ArrayIndexContext _localctx = new ArrayIndexContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_arrayIndex);
		try {
			setState(232);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(227);
				arrayIndex0();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(228);
				arrayIndex1();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(229);
				arrayIndex2();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(230);
				arrayIndex3();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(231);
				arrayIndex4();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExprKeyContext extends ParserRuleContext {
		public ArrayIndexContext arrayIndex() {
			return getRuleContext(ArrayIndexContext.class,0);
		}
		public TerminalNode STRING() { return getToken(BitQV2Parser.STRING, 0); }
		public ExprKeyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exprKey; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterExprKey(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitExprKey(this);
		}
	}

	public final ExprKeyContext exprKey() throws RecognitionException {
		ExprKeyContext _localctx = new ExprKeyContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_exprKey);
		try {
			setState(236);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case NUM:
			case COLON:
				enterOuterAlt(_localctx, 1);
				{
				setState(234);
				arrayIndex();
				}
				break;
			case STRING:
				enterOuterAlt(_localctx, 2);
				{
				setState(235);
				match(STRING);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FunctionContext extends ParserRuleContext {
		public TerminalNode FUNCTION() { return getToken(BitQV2Parser.FUNCTION, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public List<TerminalNode> NAME() { return getTokens(BitQV2Parser.NAME); }
		public TerminalNode NAME(int i) {
			return getToken(BitQV2Parser.NAME, i);
		}
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public TerminalNode ARRAY_L() { return getToken(BitQV2Parser.ARRAY_L, 0); }
		public ExprKeyContext exprKey() {
			return getRuleContext(ExprKeyContext.class,0);
		}
		public TerminalNode ARRAY_R() { return getToken(BitQV2Parser.ARRAY_R, 0); }
		public List<ValuesContext> values() {
			return getRuleContexts(ValuesContext.class);
		}
		public ValuesContext values(int i) {
			return getRuleContext(ValuesContext.class,i);
		}
		public FunctionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterFunction(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitFunction(this);
		}
	}

	public final FunctionContext function() throws RecognitionException {
		FunctionContext _localctx = new FunctionContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_function);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(238);
			match(FUNCTION);
			setState(239);
			match(Brackets_L);
			setState(240);
			match(NAME);
			setState(245);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ARRAY_L) {
				{
				setState(241);
				match(ARRAY_L);
				setState(242);
				exprKey();
				setState(243);
				match(ARRAY_R);
				}
			}

			setState(247);
			match(COMMA);
			setState(248);
			match(NAME);
			setState(253);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(249);
				match(COMMA);
				setState(250);
				values();
				}
				}
				setState(255);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(256);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BaseExprContext extends ParserRuleContext {
		public Token op;
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public ExprValueContext exprValue() {
			return getRuleContext(ExprValueContext.class,0);
		}
		public TerminalNode ARRAY_L() { return getToken(BitQV2Parser.ARRAY_L, 0); }
		public ExprKeyContext exprKey() {
			return getRuleContext(ExprKeyContext.class,0);
		}
		public TerminalNode ARRAY_R() { return getToken(BitQV2Parser.ARRAY_R, 0); }
		public BaseExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_baseExpr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterBaseExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitBaseExpr(this);
		}
	}

	public final BaseExprContext baseExpr() throws RecognitionException {
		BaseExprContext _localctx = new BaseExprContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_baseExpr);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(258);
			match(NAME);
			setState(263);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ARRAY_L) {
				{
				setState(259);
				match(ARRAY_L);
				setState(260);
				exprKey();
				setState(261);
				match(ARRAY_R);
				}
			}

			setState(265);
			((BaseExprContext)_localctx).op = _input.LT(1);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5))) != 0)) ) {
				((BaseExprContext)_localctx).op = (Token)_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(266);
			exprValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConditionExprContext extends ParserRuleContext {
		public BaseExprContext baseExpr() {
			return getRuleContext(BaseExprContext.class,0);
		}
		public FunctionContext function() {
			return getRuleContext(FunctionContext.class,0);
		}
		public ConditionExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conditionExpr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterConditionExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitConditionExpr(this);
		}
	}

	public final ConditionExprContext conditionExpr() throws RecognitionException {
		ConditionExprContext _localctx = new ConditionExprContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_conditionExpr);
		try {
			setState(270);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case NAME:
				enterOuterAlt(_localctx, 1);
				{
				setState(268);
				baseExpr();
				}
				break;
			case FUNCTION:
				enterOuterAlt(_localctx, 2);
				{
				setState(269);
				function();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QueryContext extends ParserRuleContext {
		public TerminalNode SELECT() { return getToken(BitQV2Parser.SELECT, 0); }
		public ResultContext result() {
			return getRuleContext(ResultContext.class,0);
		}
		public TerminalNode FROM() { return getToken(BitQV2Parser.FROM, 0); }
		public RepoContext repo() {
			return getRuleContext(RepoContext.class,0);
		}
		public TerminalNode WHERE() { return getToken(BitQV2Parser.WHERE, 0); }
		public OrConditionContext orCondition() {
			return getRuleContext(OrConditionContext.class,0);
		}
		public SortByContext sortBy() {
			return getRuleContext(SortByContext.class,0);
		}
		public MixContext mix() {
			return getRuleContext(MixContext.class,0);
		}
		public LimitContext limit() {
			return getRuleContext(LimitContext.class,0);
		}
		public SaveAsFileContext saveAsFile() {
			return getRuleContext(SaveAsFileContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(BitQV2Parser.SEMI, 0); }
		public QueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_query; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterQuery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitQuery(this);
		}
	}

	public final QueryContext query() throws RecognitionException {
		QueryContext _localctx = new QueryContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_query);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(272);
			match(SELECT);
			setState(273);
			result();
			setState(274);
			match(FROM);
			setState(275);
			repo();
			setState(278);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==WHERE) {
				{
				setState(276);
				match(WHERE);
				setState(277);
				orCondition();
				}
			}

			setState(281);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Order) {
				{
				setState(280);
				sortBy();
				}
			}

			setState(284);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==MIX) {
				{
				setState(283);
				mix();
				}
			}

			setState(287);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LIMIT) {
				{
				setState(286);
				limit();
				}
			}

			setState(290);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SAVE) {
				{
				setState(289);
				saveAsFile();
				}
			}

			setState(293);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEMI) {
				{
				setState(292);
				match(SEMI);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ResultContext extends ParserRuleContext {
		public List<TerminalNode> NAME() { return getTokens(BitQV2Parser.NAME); }
		public TerminalNode NAME(int i) {
			return getToken(BitQV2Parser.NAME, i);
		}
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public ResultContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_result; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterResult(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitResult(this);
		}
	}

	public final ResultContext result() throws RecognitionException {
		ResultContext _localctx = new ResultContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_result);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(295);
			match(NAME);
			setState(300);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(296);
				match(COMMA);
				setState(297);
				match(NAME);
				}
				}
				setState(302);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RepoContext extends ParserRuleContext {
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public RepoContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_repo; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterRepo(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitRepo(this);
		}
	}

	public final RepoContext repo() throws RecognitionException {
		RepoContext _localctx = new RepoContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_repo);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(303);
			match(NAME);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SortByContext extends ParserRuleContext {
		public TerminalNode Order() { return getToken(BitQV2Parser.Order, 0); }
		public TerminalNode By() { return getToken(BitQV2Parser.By, 0); }
		public List<SortEContext> sortE() {
			return getRuleContexts(SortEContext.class);
		}
		public SortEContext sortE(int i) {
			return getRuleContext(SortEContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public SortByContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sortBy; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterSortBy(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitSortBy(this);
		}
	}

	public final SortByContext sortBy() throws RecognitionException {
		SortByContext _localctx = new SortByContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_sortBy);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(305);
			match(Order);
			setState(306);
			match(By);
			setState(307);
			sortE();
			setState(312);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(308);
				match(COMMA);
				setState(309);
				sortE();
				}
				}
				setState(314);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SortEContext extends ParserRuleContext {
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public TerminalNode ARRAY_L() { return getToken(BitQV2Parser.ARRAY_L, 0); }
		public ExprKeyContext exprKey() {
			return getRuleContext(ExprKeyContext.class,0);
		}
		public TerminalNode ARRAY_R() { return getToken(BitQV2Parser.ARRAY_R, 0); }
		public TerminalNode DESC() { return getToken(BitQV2Parser.DESC, 0); }
		public TerminalNode ASC() { return getToken(BitQV2Parser.ASC, 0); }
		public SortEContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sortE; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterSortE(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitSortE(this);
		}
	}

	public final SortEContext sortE() throws RecognitionException {
		SortEContext _localctx = new SortEContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_sortE);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(315);
			match(NAME);
			setState(320);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ARRAY_L) {
				{
				setState(316);
				match(ARRAY_L);
				setState(317);
				exprKey();
				setState(318);
				match(ARRAY_R);
				}
			}

			setState(323);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==DESC || _la==ASC) {
				{
				setState(322);
				_la = _input.LA(1);
				if ( !(_la==DESC || _la==ASC) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MixContext extends ParserRuleContext {
		public TerminalNode MIX() { return getToken(BitQV2Parser.MIX, 0); }
		public FullNameContext fullName() {
			return getRuleContext(FullNameContext.class,0);
		}
		public TerminalNode ARRAY_L() { return getToken(BitQV2Parser.ARRAY_L, 0); }
		public List<TerminalNode> NUM() { return getTokens(BitQV2Parser.NUM); }
		public TerminalNode NUM(int i) {
			return getToken(BitQV2Parser.NUM, i);
		}
		public TerminalNode ARRAY_R() { return getToken(BitQV2Parser.ARRAY_R, 0); }
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public MixContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mix; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterMix(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitMix(this);
		}
	}

	public final MixContext mix() throws RecognitionException {
		MixContext _localctx = new MixContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_mix);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(325);
			match(MIX);
			setState(326);
			fullName();
			setState(337);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ARRAY_L) {
				{
				setState(327);
				match(ARRAY_L);
				setState(328);
				match(NUM);
				setState(333);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(329);
					match(COMMA);
					setState(330);
					match(NUM);
					}
					}
					setState(335);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(336);
				match(ARRAY_R);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LimitContext extends ParserRuleContext {
		public TerminalNode LIMIT() { return getToken(BitQV2Parser.LIMIT, 0); }
		public List<TerminalNode> NUM() { return getTokens(BitQV2Parser.NUM); }
		public TerminalNode NUM(int i) {
			return getToken(BitQV2Parser.NUM, i);
		}
		public TerminalNode COMMA() { return getToken(BitQV2Parser.COMMA, 0); }
		public LimitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_limit; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterLimit(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitLimit(this);
		}
	}

	public final LimitContext limit() throws RecognitionException {
		LimitContext _localctx = new LimitContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_limit);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(339);
			match(LIMIT);
			setState(340);
			match(NUM);
			setState(343);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(341);
				match(COMMA);
				setState(342);
				match(NUM);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SaveAsFileContext extends ParserRuleContext {
		public TerminalNode SAVE() { return getToken(BitQV2Parser.SAVE, 0); }
		public TerminalNode AS() { return getToken(BitQV2Parser.AS, 0); }
		public TerminalNode STRING() { return getToken(BitQV2Parser.STRING, 0); }
		public SaveAsFileContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_saveAsFile; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterSaveAsFile(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitSaveAsFile(this);
		}
	}

	public final SaveAsFileContext saveAsFile() throws RecognitionException {
		SaveAsFileContext _localctx = new SaveAsFileContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_saveAsFile);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(345);
			match(SAVE);
			setState(346);
			match(AS);
			setState(347);
			match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InsertIntoContext extends ParserRuleContext {
		public TerminalNode INSERT() { return getToken(BitQV2Parser.INSERT, 0); }
		public TerminalNode INTO() { return getToken(BitQV2Parser.INTO, 0); }
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public TerminalNode VALUES() { return getToken(BitQV2Parser.VALUES, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public List<ExprValueContext> exprValue() {
			return getRuleContexts(ExprValueContext.class);
		}
		public ExprValueContext exprValue(int i) {
			return getRuleContext(ExprValueContext.class,i);
		}
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public FieldsContext fields() {
			return getRuleContext(FieldsContext.class,0);
		}
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public TerminalNode SEMI() { return getToken(BitQV2Parser.SEMI, 0); }
		public InsertIntoContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_insertInto; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterInsertInto(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitInsertInto(this);
		}
	}

	public final InsertIntoContext insertInto() throws RecognitionException {
		InsertIntoContext _localctx = new InsertIntoContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_insertInto);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(349);
			match(INSERT);
			setState(350);
			match(INTO);
			setState(351);
			match(NAME);
			setState(353);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Brackets_L) {
				{
				setState(352);
				fields();
				}
			}

			setState(355);
			match(VALUES);
			setState(356);
			match(Brackets_L);
			setState(357);
			exprValue();
			setState(362);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(358);
				match(COMMA);
				setState(359);
				exprValue();
				}
				}
				setState(364);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(365);
			match(Brackets_R);
			setState(367);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEMI) {
				{
				setState(366);
				match(SEMI);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetValueContext extends ParserRuleContext {
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public ValuesContext values() {
			return getRuleContext(ValuesContext.class,0);
		}
		public SetValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setValue; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterSetValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitSetValue(this);
		}
	}

	public final SetValueContext setValue() throws RecognitionException {
		SetValueContext _localctx = new SetValueContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_setValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(369);
			match(NAME);
			setState(370);
			match(T__0);
			setState(371);
			values();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UpdateContext extends ParserRuleContext {
		public TerminalNode UPDATE() { return getToken(BitQV2Parser.UPDATE, 0); }
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public TerminalNode SET() { return getToken(BitQV2Parser.SET, 0); }
		public List<SetValueContext> setValue() {
			return getRuleContexts(SetValueContext.class);
		}
		public SetValueContext setValue(int i) {
			return getRuleContext(SetValueContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public TerminalNode WHERE() { return getToken(BitQV2Parser.WHERE, 0); }
		public OrConditionContext orCondition() {
			return getRuleContext(OrConditionContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(BitQV2Parser.SEMI, 0); }
		public UpdateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_update; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterUpdate(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitUpdate(this);
		}
	}

	public final UpdateContext update() throws RecognitionException {
		UpdateContext _localctx = new UpdateContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_update);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(373);
			match(UPDATE);
			setState(374);
			match(NAME);
			setState(375);
			match(SET);
			setState(376);
			setValue();
			setState(381);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(377);
				match(COMMA);
				setState(378);
				setValue();
				}
				}
				setState(383);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(386);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==WHERE) {
				{
				setState(384);
				match(WHERE);
				setState(385);
				orCondition();
				}
			}

			setState(389);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEMI) {
				{
				setState(388);
				match(SEMI);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DeleteContext extends ParserRuleContext {
		public TerminalNode DELETE() { return getToken(BitQV2Parser.DELETE, 0); }
		public TerminalNode FROM() { return getToken(BitQV2Parser.FROM, 0); }
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public TerminalNode WHERE() { return getToken(BitQV2Parser.WHERE, 0); }
		public OrConditionContext orCondition() {
			return getRuleContext(OrConditionContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(BitQV2Parser.SEMI, 0); }
		public DeleteContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_delete; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterDelete(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitDelete(this);
		}
	}

	public final DeleteContext delete() throws RecognitionException {
		DeleteContext _localctx = new DeleteContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_delete);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(391);
			match(DELETE);
			setState(392);
			match(FROM);
			setState(393);
			match(NAME);
			setState(396);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==WHERE) {
				{
				setState(394);
				match(WHERE);
				setState(395);
				orCondition();
				}
			}

			setState(399);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEMI) {
				{
				setState(398);
				match(SEMI);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetSourceContext extends ParserRuleContext {
		public TerminalNode SET() { return getToken(BitQV2Parser.SET, 0); }
		public TerminalNode SOURCE() { return getToken(BitQV2Parser.SOURCE, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public TerminalNode NUM() { return getToken(BitQV2Parser.NUM, 0); }
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public SetSourceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setSource; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterSetSource(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitSetSource(this);
		}
	}

	public final SetSourceContext setSource() throws RecognitionException {
		SetSourceContext _localctx = new SetSourceContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_setSource);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(401);
			match(SET);
			setState(402);
			match(SOURCE);
			setState(403);
			match(Brackets_L);
			setState(404);
			match(NUM);
			setState(405);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CreateTableContext extends ParserRuleContext {
		public TerminalNode CREATE() { return getToken(BitQV2Parser.CREATE, 0); }
		public TerminalNode TABLE() { return getToken(BitQV2Parser.TABLE, 0); }
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public List<ColumnContext> column() {
			return getRuleContexts(ColumnContext.class);
		}
		public ColumnContext column(int i) {
			return getRuleContext(ColumnContext.class,i);
		}
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public SetSourceContext setSource() {
			return getRuleContext(SetSourceContext.class,0);
		}
		public CreateTableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_createTable; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterCreateTable(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitCreateTable(this);
		}
	}

	public final CreateTableContext createTable() throws RecognitionException {
		CreateTableContext _localctx = new CreateTableContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_createTable);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(407);
			match(CREATE);
			setState(408);
			match(TABLE);
			setState(409);
			match(NAME);
			setState(410);
			match(Brackets_L);
			setState(411);
			column();
			setState(416);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(412);
				match(COMMA);
				setState(413);
				column();
				}
				}
				setState(418);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(419);
			match(Brackets_R);
			setState(422);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(420);
				match(COMMA);
				setState(421);
				setSource();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnContext extends ParserRuleContext {
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public CTypeContext cType() {
			return getRuleContext(CTypeContext.class,0);
		}
		public ColumnContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_column; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterColumn(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitColumn(this);
		}
	}

	public final ColumnContext column() throws RecognitionException {
		ColumnContext _localctx = new ColumnContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_column);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(424);
			match(NAME);
			setState(425);
			cType();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CTypeContext extends ParserRuleContext {
		public IntTypeContext intType() {
			return getRuleContext(IntTypeContext.class,0);
		}
		public UintTypeContext uintType() {
			return getRuleContext(UintTypeContext.class,0);
		}
		public DateTypeContext dateType() {
			return getRuleContext(DateTypeContext.class,0);
		}
		public FloatTypeContext floatType() {
			return getRuleContext(FloatTypeContext.class,0);
		}
		public UfloatTypeContext ufloatType() {
			return getRuleContext(UfloatTypeContext.class,0);
		}
		public BooleanTypeContext booleanType() {
			return getRuleContext(BooleanTypeContext.class,0);
		}
		public LongTypeContext longType() {
			return getRuleContext(LongTypeContext.class,0);
		}
		public UlongTypeContext ulongType() {
			return getRuleContext(UlongTypeContext.class,0);
		}
		public PhoneTypeContext phoneType() {
			return getRuleContext(PhoneTypeContext.class,0);
		}
		public ListTypeContext listType() {
			return getRuleContext(ListTypeContext.class,0);
		}
		public MapTypeContext mapType() {
			return getRuleContext(MapTypeContext.class,0);
		}
		public CTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterCType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitCType(this);
		}
	}

	public final CTypeContext cType() throws RecognitionException {
		CTypeContext _localctx = new CTypeContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_cType);
		try {
			setState(438);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case INT:
				enterOuterAlt(_localctx, 1);
				{
				setState(427);
				intType();
				}
				break;
			case UINT:
				enterOuterAlt(_localctx, 2);
				{
				setState(428);
				uintType();
				}
				break;
			case DATE:
				enterOuterAlt(_localctx, 3);
				{
				setState(429);
				dateType();
				}
				break;
			case FLOAT:
				enterOuterAlt(_localctx, 4);
				{
				setState(430);
				floatType();
				}
				break;
			case UFLOAT:
				enterOuterAlt(_localctx, 5);
				{
				setState(431);
				ufloatType();
				}
				break;
			case BOOLEAN:
				enterOuterAlt(_localctx, 6);
				{
				setState(432);
				booleanType();
				}
				break;
			case LONG:
				enterOuterAlt(_localctx, 7);
				{
				setState(433);
				longType();
				}
				break;
			case ULONG:
				enterOuterAlt(_localctx, 8);
				{
				setState(434);
				ulongType();
				}
				break;
			case PHONE:
				enterOuterAlt(_localctx, 9);
				{
				setState(435);
				phoneType();
				}
				break;
			case LIST:
				enterOuterAlt(_localctx, 10);
				{
				setState(436);
				listType();
				}
				break;
			case MAP:
				enterOuterAlt(_localctx, 11);
				{
				setState(437);
				mapType();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IntTypeContext extends ParserRuleContext {
		public TerminalNode INT() { return getToken(BitQV2Parser.INT, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public TerminalNode NUM() { return getToken(BitQV2Parser.NUM, 0); }
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public IntTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_intType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterIntType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitIntType(this);
		}
	}

	public final IntTypeContext intType() throws RecognitionException {
		IntTypeContext _localctx = new IntTypeContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_intType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(440);
			match(INT);
			setState(441);
			match(Brackets_L);
			setState(442);
			match(NUM);
			setState(443);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UintTypeContext extends ParserRuleContext {
		public TerminalNode UINT() { return getToken(BitQV2Parser.UINT, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public TerminalNode NUM() { return getToken(BitQV2Parser.NUM, 0); }
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public UintTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_uintType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterUintType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitUintType(this);
		}
	}

	public final UintTypeContext uintType() throws RecognitionException {
		UintTypeContext _localctx = new UintTypeContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_uintType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(445);
			match(UINT);
			setState(446);
			match(Brackets_L);
			setState(447);
			match(NUM);
			setState(448);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DateTypeContext extends ParserRuleContext {
		public TerminalNode DATE() { return getToken(BitQV2Parser.DATE, 0); }
		public DateTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dateType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterDateType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitDateType(this);
		}
	}

	public final DateTypeContext dateType() throws RecognitionException {
		DateTypeContext _localctx = new DateTypeContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_dateType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(450);
			match(DATE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FloatTypeContext extends ParserRuleContext {
		public TerminalNode FLOAT() { return getToken(BitQV2Parser.FLOAT, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public List<TerminalNode> NUM() { return getTokens(BitQV2Parser.NUM); }
		public TerminalNode NUM(int i) {
			return getToken(BitQV2Parser.NUM, i);
		}
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public FloatTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_floatType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterFloatType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitFloatType(this);
		}
	}

	public final FloatTypeContext floatType() throws RecognitionException {
		FloatTypeContext _localctx = new FloatTypeContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_floatType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(452);
			match(FLOAT);
			setState(453);
			match(Brackets_L);
			setState(454);
			match(NUM);
			setState(455);
			match(COMMA);
			setState(456);
			match(NUM);
			setState(459);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(457);
				match(COMMA);
				setState(458);
				match(NUM);
				}
			}

			setState(461);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UfloatTypeContext extends ParserRuleContext {
		public TerminalNode UFLOAT() { return getToken(BitQV2Parser.UFLOAT, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public List<TerminalNode> NUM() { return getTokens(BitQV2Parser.NUM); }
		public TerminalNode NUM(int i) {
			return getToken(BitQV2Parser.NUM, i);
		}
		public TerminalNode COMMA() { return getToken(BitQV2Parser.COMMA, 0); }
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public UfloatTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ufloatType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterUfloatType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitUfloatType(this);
		}
	}

	public final UfloatTypeContext ufloatType() throws RecognitionException {
		UfloatTypeContext _localctx = new UfloatTypeContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_ufloatType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(463);
			match(UFLOAT);
			setState(464);
			match(Brackets_L);
			setState(465);
			match(NUM);
			setState(466);
			match(COMMA);
			setState(467);
			match(NUM);
			setState(468);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BooleanTypeContext extends ParserRuleContext {
		public TerminalNode BOOLEAN() { return getToken(BitQV2Parser.BOOLEAN, 0); }
		public BooleanTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_booleanType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterBooleanType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitBooleanType(this);
		}
	}

	public final BooleanTypeContext booleanType() throws RecognitionException {
		BooleanTypeContext _localctx = new BooleanTypeContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_booleanType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(470);
			match(BOOLEAN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LongTypeContext extends ParserRuleContext {
		public TerminalNode LONG() { return getToken(BitQV2Parser.LONG, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public List<TerminalNode> NUM() { return getTokens(BitQV2Parser.NUM); }
		public TerminalNode NUM(int i) {
			return getToken(BitQV2Parser.NUM, i);
		}
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public TerminalNode COMMA() { return getToken(BitQV2Parser.COMMA, 0); }
		public LongTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_longType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterLongType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitLongType(this);
		}
	}

	public final LongTypeContext longType() throws RecognitionException {
		LongTypeContext _localctx = new LongTypeContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_longType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(472);
			match(LONG);
			setState(473);
			match(Brackets_L);
			setState(474);
			match(NUM);
			setState(477);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(475);
				match(COMMA);
				setState(476);
				match(NUM);
				}
			}

			setState(479);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UlongTypeContext extends ParserRuleContext {
		public TerminalNode ULONG() { return getToken(BitQV2Parser.ULONG, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public TerminalNode NUM() { return getToken(BitQV2Parser.NUM, 0); }
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public UlongTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ulongType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterUlongType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitUlongType(this);
		}
	}

	public final UlongTypeContext ulongType() throws RecognitionException {
		UlongTypeContext _localctx = new UlongTypeContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_ulongType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(481);
			match(ULONG);
			setState(482);
			match(Brackets_L);
			setState(483);
			match(NUM);
			setState(484);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PhoneTypeContext extends ParserRuleContext {
		public TerminalNode PHONE() { return getToken(BitQV2Parser.PHONE, 0); }
		public PhoneTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_phoneType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterPhoneType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitPhoneType(this);
		}
	}

	public final PhoneTypeContext phoneType() throws RecognitionException {
		PhoneTypeContext _localctx = new PhoneTypeContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_phoneType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(486);
			match(PHONE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListTypeContext extends ParserRuleContext {
		public TerminalNode LIST() { return getToken(BitQV2Parser.LIST, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public CTypeContext cType() {
			return getRuleContext(CTypeContext.class,0);
		}
		public TerminalNode COMMA() { return getToken(BitQV2Parser.COMMA, 0); }
		public TerminalNode NUM() { return getToken(BitQV2Parser.NUM, 0); }
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public ListTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterListType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitListType(this);
		}
	}

	public final ListTypeContext listType() throws RecognitionException {
		ListTypeContext _localctx = new ListTypeContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_listType);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(488);
			match(LIST);
			setState(489);
			match(Brackets_L);
			setState(490);
			cType();
			setState(491);
			match(COMMA);
			setState(492);
			match(NUM);
			setState(493);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MapTypeContext extends ParserRuleContext {
		public TerminalNode MAP() { return getToken(BitQV2Parser.MAP, 0); }
		public TerminalNode Brackets_L() { return getToken(BitQV2Parser.Brackets_L, 0); }
		public CTypeContext cType() {
			return getRuleContext(CTypeContext.class,0);
		}
		public List<TerminalNode> COMMA() { return getTokens(BitQV2Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(BitQV2Parser.COMMA, i);
		}
		public List<TerminalNode> NAME() { return getTokens(BitQV2Parser.NAME); }
		public TerminalNode NAME(int i) {
			return getToken(BitQV2Parser.NAME, i);
		}
		public TerminalNode Brackets_R() { return getToken(BitQV2Parser.Brackets_R, 0); }
		public MapTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mapType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterMapType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitMapType(this);
		}
	}

	public final MapTypeContext mapType() throws RecognitionException {
		MapTypeContext _localctx = new MapTypeContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_mapType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(495);
			match(MAP);
			setState(496);
			match(Brackets_L);
			setState(497);
			cType();
			setState(498);
			match(COMMA);
			setState(499);
			match(NAME);
			setState(504);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(500);
				match(COMMA);
				setState(501);
				match(NAME);
				}
				}
				setState(506);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(507);
			match(Brackets_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AlertTableContext extends ParserRuleContext {
		public TerminalNode ALTER() { return getToken(BitQV2Parser.ALTER, 0); }
		public TerminalNode TABLE() { return getToken(BitQV2Parser.TABLE, 0); }
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public AlertOPContext alertOP() {
			return getRuleContext(AlertOPContext.class,0);
		}
		public AlertTableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_alertTable; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterAlertTable(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitAlertTable(this);
		}
	}

	public final AlertTableContext alertTable() throws RecognitionException {
		AlertTableContext _localctx = new AlertTableContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_alertTable);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(509);
			match(ALTER);
			setState(510);
			match(TABLE);
			setState(511);
			match(NAME);
			setState(512);
			alertOP();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AlertOPContext extends ParserRuleContext {
		public TerminalNode ADD() { return getToken(BitQV2Parser.ADD, 0); }
		public ColumnContext column() {
			return getRuleContext(ColumnContext.class,0);
		}
		public TerminalNode DROP() { return getToken(BitQV2Parser.DROP, 0); }
		public TerminalNode NAME() { return getToken(BitQV2Parser.NAME, 0); }
		public TerminalNode ALTER() { return getToken(BitQV2Parser.ALTER, 0); }
		public SetSourceContext setSource() {
			return getRuleContext(SetSourceContext.class,0);
		}
		public AlertOPContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_alertOP; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).enterAlertOP(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof BitQV2Listener ) ((BitQV2Listener)listener).exitAlertOP(this);
		}
	}

	public final AlertOPContext alertOP() throws RecognitionException {
		AlertOPContext _localctx = new AlertOPContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_alertOP);
		try {
			setState(522);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case ADD:
				enterOuterAlt(_localctx, 1);
				{
				setState(514);
				match(ADD);
				setState(515);
				column();
				}
				break;
			case DROP:
				enterOuterAlt(_localctx, 2);
				{
				setState(516);
				match(DROP);
				setState(517);
				match(NAME);
				}
				break;
			case ALTER:
				enterOuterAlt(_localctx, 3);
				{
				setState(518);
				match(ALTER);
				setState(519);
				match(NAME);
				setState(520);
				column();
				}
				break;
			case SET:
				enterOuterAlt(_localctx, 4);
				{
				setState(521);
				setSource();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3P\u020f\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
		"\64\4\65\t\65\4\66\t\66\4\67\t\67\3\2\3\2\3\2\3\2\3\2\3\2\5\2u\n\2\3\3"+
		"\3\3\3\3\3\3\7\3{\n\3\f\3\16\3~\13\3\3\3\3\3\3\4\3\4\3\4\7\4\u0085\n\4"+
		"\f\4\16\4\u0088\13\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\5\6\u0095"+
		"\n\6\3\7\3\7\5\7\u0099\n\7\3\b\5\b\u009c\n\b\3\b\3\b\3\b\3\b\7\b\u00a2"+
		"\n\b\f\b\16\b\u00a5\13\b\3\t\3\t\3\t\3\t\7\t\u00ab\n\t\f\t\16\t\u00ae"+
		"\13\t\3\n\3\n\5\n\u00b2\n\n\3\13\3\13\3\13\3\13\3\f\3\f\3\r\3\r\3\r\3"+
		"\r\3\r\3\r\5\r\u00c0\n\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\17\3\17"+
		"\3\17\3\17\7\17\u00cd\n\17\f\17\16\17\u00d0\13\17\3\17\3\17\3\20\3\20"+
		"\5\20\u00d6\n\20\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24"+
		"\3\24\3\25\3\25\3\26\3\26\3\26\3\26\3\26\5\26\u00eb\n\26\3\27\3\27\5\27"+
		"\u00ef\n\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u00f8\n\30\3\30\3"+
		"\30\3\30\3\30\7\30\u00fe\n\30\f\30\16\30\u0101\13\30\3\30\3\30\3\31\3"+
		"\31\3\31\3\31\3\31\5\31\u010a\n\31\3\31\3\31\3\31\3\32\3\32\5\32\u0111"+
		"\n\32\3\33\3\33\3\33\3\33\3\33\3\33\5\33\u0119\n\33\3\33\5\33\u011c\n"+
		"\33\3\33\5\33\u011f\n\33\3\33\5\33\u0122\n\33\3\33\5\33\u0125\n\33\3\33"+
		"\5\33\u0128\n\33\3\34\3\34\3\34\7\34\u012d\n\34\f\34\16\34\u0130\13\34"+
		"\3\35\3\35\3\36\3\36\3\36\3\36\3\36\7\36\u0139\n\36\f\36\16\36\u013c\13"+
		"\36\3\37\3\37\3\37\3\37\3\37\5\37\u0143\n\37\3\37\5\37\u0146\n\37\3 \3"+
		" \3 \3 \3 \3 \7 \u014e\n \f \16 \u0151\13 \3 \5 \u0154\n \3!\3!\3!\3!"+
		"\5!\u015a\n!\3\"\3\"\3\"\3\"\3#\3#\3#\3#\5#\u0164\n#\3#\3#\3#\3#\3#\7"+
		"#\u016b\n#\f#\16#\u016e\13#\3#\3#\5#\u0172\n#\3$\3$\3$\3$\3%\3%\3%\3%"+
		"\3%\3%\7%\u017e\n%\f%\16%\u0181\13%\3%\3%\5%\u0185\n%\3%\5%\u0188\n%\3"+
		"&\3&\3&\3&\3&\5&\u018f\n&\3&\5&\u0192\n&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3"+
		"(\3(\3(\3(\3(\3(\7(\u01a1\n(\f(\16(\u01a4\13(\3(\3(\3(\5(\u01a9\n(\3)"+
		"\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\5*\u01b9\n*\3+\3+\3+\3+\3+\3,"+
		"\3,\3,\3,\3,\3-\3-\3.\3.\3.\3.\3.\3.\3.\5.\u01ce\n.\3.\3.\3/\3/\3/\3/"+
		"\3/\3/\3/\3\60\3\60\3\61\3\61\3\61\3\61\3\61\5\61\u01e0\n\61\3\61\3\61"+
		"\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3\64"+
		"\3\65\3\65\3\65\3\65\3\65\3\65\3\65\7\65\u01f9\n\65\f\65\16\65\u01fc\13"+
		"\65\3\65\3\65\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\3"+
		"\67\3\67\5\67\u020d\n\67\3\67\2\28\2\4\6\b\n\f\16\20\22\24\26\30\32\34"+
		"\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjl\2\6\3\2$&\3\2\36"+
		"\37\3\2\3\b\3\2\27\30\2\u021c\2t\3\2\2\2\4v\3\2\2\2\6\u0081\3\2\2\2\b"+
		"\u0089\3\2\2\2\n\u0092\3\2\2\2\f\u0096\3\2\2\2\16\u009b\3\2\2\2\20\u00a6"+
		"\3\2\2\2\22\u00b1\3\2\2\2\24\u00b3\3\2\2\2\26\u00b7\3\2\2\2\30\u00bf\3"+
		"\2\2\2\32\u00c1\3\2\2\2\34\u00c8\3\2\2\2\36\u00d5\3\2\2\2 \u00d7\3\2\2"+
		"\2\"\u00d9\3\2\2\2$\u00dd\3\2\2\2&\u00e0\3\2\2\2(\u00e3\3\2\2\2*\u00ea"+
		"\3\2\2\2,\u00ee\3\2\2\2.\u00f0\3\2\2\2\60\u0104\3\2\2\2\62\u0110\3\2\2"+
		"\2\64\u0112\3\2\2\2\66\u0129\3\2\2\28\u0131\3\2\2\2:\u0133\3\2\2\2<\u013d"+
		"\3\2\2\2>\u0147\3\2\2\2@\u0155\3\2\2\2B\u015b\3\2\2\2D\u015f\3\2\2\2F"+
		"\u0173\3\2\2\2H\u0177\3\2\2\2J\u0189\3\2\2\2L\u0193\3\2\2\2N\u0199\3\2"+
		"\2\2P\u01aa\3\2\2\2R\u01b8\3\2\2\2T\u01ba\3\2\2\2V\u01bf\3\2\2\2X\u01c4"+
		"\3\2\2\2Z\u01c6\3\2\2\2\\\u01d1\3\2\2\2^\u01d8\3\2\2\2`\u01da\3\2\2\2"+
		"b\u01e3\3\2\2\2d\u01e8\3\2\2\2f\u01ea\3\2\2\2h\u01f1\3\2\2\2j\u01ff\3"+
		"\2\2\2l\u020c\3\2\2\2nu\5\64\33\2ou\5D#\2pu\5H%\2qu\5J&\2ru\5j\66\2su"+
		"\5N(\2tn\3\2\2\2to\3\2\2\2tp\3\2\2\2tq\3\2\2\2tr\3\2\2\2ts\3\2\2\2u\3"+
		"\3\2\2\2vw\7L\2\2w|\7H\2\2xy\7F\2\2y{\7H\2\2zx\3\2\2\2{~\3\2\2\2|z\3\2"+
		"\2\2|}\3\2\2\2}\177\3\2\2\2~|\3\2\2\2\177\u0080\7M\2\2\u0080\5\3\2\2\2"+
		"\u0081\u0086\7H\2\2\u0082\u0083\7I\2\2\u0083\u0085\7H\2\2\u0084\u0082"+
		"\3\2\2\2\u0085\u0088\3\2\2\2\u0086\u0084\3\2\2\2\u0086\u0087\3\2\2\2\u0087"+
		"\7\3\2\2\2\u0088\u0086\3\2\2\2\u0089\u008a\7#\2\2\u008a\u008b\7L\2\2\u008b"+
		"\u008c\5\6\4\2\u008c\u008d\7F\2\2\u008d\u008e\t\2\2\2\u008e\u008f\7F\2"+
		"\2\u008f\u0090\7\34\2\2\u0090\u0091\7M\2\2\u0091\t\3\2\2\2\u0092\u0094"+
		"\7\21\2\2\u0093\u0095\7\22\2\2\u0094\u0093\3\2\2\2\u0094\u0095\3\2\2\2"+
		"\u0095\13\3\2\2\2\u0096\u0098\7\20\2\2\u0097\u0099\7\22\2\2\u0098\u0097"+
		"\3\2\2\2\u0098\u0099\3\2\2\2\u0099\r\3\2\2\2\u009a\u009c\7\22\2\2\u009b"+
		"\u009a\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u00a3\5\20"+
		"\t\2\u009e\u009f\5\n\6\2\u009f\u00a0\5\20\t\2\u00a0\u00a2\3\2\2\2\u00a1"+
		"\u009e\3\2\2\2\u00a2\u00a5\3\2\2\2\u00a3\u00a1\3\2\2\2\u00a3\u00a4\3\2"+
		"\2\2\u00a4\17\3\2\2\2\u00a5\u00a3\3\2\2\2\u00a6\u00ac\5\22\n\2\u00a7\u00a8"+
		"\5\f\7\2\u00a8\u00a9\5\22\n\2\u00a9\u00ab\3\2\2\2\u00aa\u00a7\3\2\2\2"+
		"\u00ab\u00ae\3\2\2\2\u00ac\u00aa\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\21"+
		"\3\2\2\2\u00ae\u00ac\3\2\2\2\u00af\u00b2\5\24\13\2\u00b0\u00b2\5\62\32"+
		"\2\u00b1\u00af\3\2\2\2\u00b1\u00b0\3\2\2\2\u00b2\23\3\2\2\2\u00b3\u00b4"+
		"\7L\2\2\u00b4\u00b5\5\16\b\2\u00b5\u00b6\7M\2\2\u00b6\25\3\2\2\2\u00b7"+
		"\u00b8\t\3\2\2\u00b8\27\3\2\2\2\u00b9\u00c0\5\32\16\2\u00ba\u00c0\7\34"+
		"\2\2\u00bb\u00c0\7\35\2\2\u00bc\u00c0\5\26\f\2\u00bd\u00c0\7\"\2\2\u00be"+
		"\u00c0\7 \2\2\u00bf\u00b9\3\2\2\2\u00bf\u00ba\3\2\2\2\u00bf\u00bb\3\2"+
		"\2\2\u00bf\u00bc\3\2\2\2\u00bf\u00bd\3\2\2\2\u00bf\u00be\3\2\2\2\u00c0"+
		"\31\3\2\2\2\u00c1\u00c2\7!\2\2\u00c2\u00c3\7L\2\2\u00c3\u00c4\7\34\2\2"+
		"\u00c4\u00c5\7F\2\2\u00c5\u00c6\7\34\2\2\u00c6\u00c7\7M\2\2\u00c7\33\3"+
		"\2\2\2\u00c8\u00c9\7J\2\2\u00c9\u00ce\5\30\r\2\u00ca\u00cb\7F\2\2\u00cb"+
		"\u00cd\5\30\r\2\u00cc\u00ca\3\2\2\2\u00cd\u00d0\3\2\2\2\u00ce\u00cc\3"+
		"\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d1\3\2\2\2\u00d0\u00ce\3\2\2\2\u00d1"+
		"\u00d2\7K\2\2\u00d2\35\3\2\2\2\u00d3\u00d6\5\30\r\2\u00d4\u00d6\5\34\17"+
		"\2\u00d5\u00d3\3\2\2\2\u00d5\u00d4\3\2\2\2\u00d6\37\3\2\2\2\u00d7\u00d8"+
		"\7\35\2\2\u00d8!\3\2\2\2\u00d9\u00da\7\35\2\2\u00da\u00db\7N\2\2\u00db"+
		"\u00dc\7\35\2\2\u00dc#\3\2\2\2\u00dd\u00de\7\35\2\2\u00de\u00df\7N\2\2"+
		"\u00df%\3\2\2\2\u00e0\u00e1\7N\2\2\u00e1\u00e2\7\35\2\2\u00e2\'\3\2\2"+
		"\2\u00e3\u00e4\7N\2\2\u00e4)\3\2\2\2\u00e5\u00eb\5 \21\2\u00e6\u00eb\5"+
		"\"\22\2\u00e7\u00eb\5$\23\2\u00e8\u00eb\5&\24\2\u00e9\u00eb\5(\25\2\u00ea"+
		"\u00e5\3\2\2\2\u00ea\u00e6\3\2\2\2\u00ea\u00e7\3\2\2\2\u00ea\u00e8\3\2"+
		"\2\2\u00ea\u00e9\3\2\2\2\u00eb+\3\2\2\2\u00ec\u00ef\5*\26\2\u00ed\u00ef"+
		"\7\34\2\2\u00ee\u00ec\3\2\2\2\u00ee\u00ed\3\2\2\2\u00ef-\3\2\2\2\u00f0"+
		"\u00f1\7\24\2\2\u00f1\u00f2\7L\2\2\u00f2\u00f7\7H\2\2\u00f3\u00f4\7J\2"+
		"\2\u00f4\u00f5\5,\27\2\u00f5\u00f6\7K\2\2\u00f6\u00f8\3\2\2\2\u00f7\u00f3"+
		"\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fa\7F\2\2\u00fa"+
		"\u00ff\7H\2\2\u00fb\u00fc\7F\2\2\u00fc\u00fe\5\30\r\2\u00fd\u00fb\3\2"+
		"\2\2\u00fe\u0101\3\2\2\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100"+
		"\u0102\3\2\2\2\u0101\u00ff\3\2\2\2\u0102\u0103\7M\2\2\u0103/\3\2\2\2\u0104"+
		"\u0109\7H\2\2\u0105\u0106\7J\2\2\u0106\u0107\5,\27\2\u0107\u0108\7K\2"+
		"\2\u0108\u010a\3\2\2\2\u0109\u0105\3\2\2\2\u0109\u010a\3\2\2\2\u010a\u010b"+
		"\3\2\2\2\u010b\u010c\t\4\2\2\u010c\u010d\5\36\20\2\u010d\61\3\2\2\2\u010e"+
		"\u0111\5\60\31\2\u010f\u0111\5.\30\2\u0110\u010e\3\2\2\2\u0110\u010f\3"+
		"\2\2\2\u0111\63\3\2\2\2\u0112\u0113\7\t\2\2\u0113\u0114\5\66\34\2\u0114"+
		"\u0115\7\n\2\2\u0115\u0118\58\35\2\u0116\u0117\7\17\2\2\u0117\u0119\5"+
		"\16\b\2\u0118\u0116\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011b\3\2\2\2\u011a"+
		"\u011c\5:\36\2\u011b\u011a\3\2\2\2\u011b\u011c\3\2\2\2\u011c\u011e\3\2"+
		"\2\2\u011d\u011f\5> \2\u011e\u011d\3\2\2\2\u011e\u011f\3\2\2\2\u011f\u0121"+
		"\3\2\2\2\u0120\u0122\5@!\2\u0121\u0120\3\2\2\2\u0121\u0122\3\2\2\2\u0122"+
		"\u0124\3\2\2\2\u0123\u0125\5B\"\2\u0124\u0123\3\2\2\2\u0124\u0125\3\2"+
		"\2\2\u0125\u0127\3\2\2\2\u0126\u0128\7G\2\2\u0127\u0126\3\2\2\2\u0127"+
		"\u0128\3\2\2\2\u0128\65\3\2\2\2\u0129\u012e\7H\2\2\u012a\u012b\7F\2\2"+
		"\u012b\u012d\7H\2\2\u012c\u012a\3\2\2\2\u012d\u0130\3\2\2\2\u012e\u012c"+
		"\3\2\2\2\u012e\u012f\3\2\2\2\u012f\67\3\2\2\2\u0130\u012e\3\2\2\2\u0131"+
		"\u0132\7H\2\2\u01329\3\2\2\2\u0133\u0134\7\25\2\2\u0134\u0135\7\26\2\2"+
		"\u0135\u013a\5<\37\2\u0136\u0137\7F\2\2\u0137\u0139\5<\37\2\u0138\u0136"+
		"\3\2\2\2\u0139\u013c\3\2\2\2\u013a\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b"+
		";\3\2\2\2\u013c\u013a\3\2\2\2\u013d\u0142\7H\2\2\u013e\u013f\7J\2\2\u013f"+
		"\u0140\5,\27\2\u0140\u0141\7K\2\2\u0141\u0143\3\2\2\2\u0142\u013e\3\2"+
		"\2\2\u0142\u0143\3\2\2\2\u0143\u0145\3\2\2\2\u0144\u0146\t\5\2\2\u0145"+
		"\u0144\3\2\2\2\u0145\u0146\3\2\2\2\u0146=\3\2\2\2\u0147\u0148\7\31\2\2"+
		"\u0148\u0153\5\6\4\2\u0149\u014a\7J\2\2\u014a\u014f\7\35\2\2\u014b\u014c"+
		"\7F\2\2\u014c\u014e\7\35\2\2\u014d\u014b\3\2\2\2\u014e\u0151\3\2\2\2\u014f"+
		"\u014d\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0152\3\2\2\2\u0151\u014f\3\2"+
		"\2\2\u0152\u0154\7K\2\2\u0153\u0149\3\2\2\2\u0153\u0154\3\2\2\2\u0154"+
		"?\3\2\2\2\u0155\u0156\7\61\2\2\u0156\u0159\7\35\2\2\u0157\u0158\7F\2\2"+
		"\u0158\u015a\7\35\2\2\u0159\u0157\3\2\2\2\u0159\u015a\3\2\2\2\u015aA\3"+
		"\2\2\2\u015b\u015c\7,\2\2\u015c\u015d\7-\2\2\u015d\u015e\7\34\2\2\u015e"+
		"C\3\2\2\2\u015f\u0160\7)\2\2\u0160\u0161\7*\2\2\u0161\u0163\7H\2\2\u0162"+
		"\u0164\5\4\3\2\u0163\u0162\3\2\2\2\u0163\u0164\3\2\2\2\u0164\u0165\3\2"+
		"\2\2\u0165\u0166\7+\2\2\u0166\u0167\7L\2\2\u0167\u016c\5\36\20\2\u0168"+
		"\u0169\7F\2\2\u0169\u016b\5\36\20\2\u016a\u0168\3\2\2\2\u016b\u016e\3"+
		"\2\2\2\u016c\u016a\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016f\3\2\2\2\u016e"+
		"\u016c\3\2\2\2\u016f\u0171\7M\2\2\u0170\u0172\7G\2\2\u0171\u0170\3\2\2"+
		"\2\u0171\u0172\3\2\2\2\u0172E\3\2\2\2\u0173\u0174\7H\2\2\u0174\u0175\7"+
		"\3\2\2\u0175\u0176\5\30\r\2\u0176G\3\2\2\2\u0177\u0178\7.\2\2\u0178\u0179"+
		"\7H\2\2\u0179\u017a\7/\2\2\u017a\u017f\5F$\2\u017b\u017c\7F\2\2\u017c"+
		"\u017e\5F$\2\u017d\u017b\3\2\2\2\u017e\u0181\3\2\2\2\u017f\u017d\3\2\2"+
		"\2\u017f\u0180\3\2\2\2\u0180\u0184\3\2\2\2\u0181\u017f\3\2\2\2\u0182\u0183"+
		"\7\17\2\2\u0183\u0185\5\16\b\2\u0184\u0182\3\2\2\2\u0184\u0185\3\2\2\2"+
		"\u0185\u0187\3\2\2\2\u0186\u0188\7G\2\2\u0187\u0186\3\2\2\2\u0187\u0188"+
		"\3\2\2\2\u0188I\3\2\2\2\u0189\u018a\7\60\2\2\u018a\u018b\7\n\2\2\u018b"+
		"\u018e\7H\2\2\u018c\u018d\7\17\2\2\u018d\u018f\5\16\b\2\u018e\u018c\3"+
		"\2\2\2\u018e\u018f\3\2\2\2\u018f\u0191\3\2\2\2\u0190\u0192\7G\2\2\u0191"+
		"\u0190\3\2\2\2\u0191\u0192\3\2\2\2\u0192K\3\2\2\2\u0193\u0194\7/\2\2\u0194"+
		"\u0195\7\66\2\2\u0195\u0196\7L\2\2\u0196\u0197\7\35\2\2\u0197\u0198\7"+
		"M\2\2\u0198M\3\2\2\2\u0199\u019a\7\62\2\2\u019a\u019b\78\2\2\u019b\u019c"+
		"\7H\2\2\u019c\u019d\7L\2\2\u019d\u01a2\5P)\2\u019e\u019f\7F\2\2\u019f"+
		"\u01a1\5P)\2\u01a0\u019e\3\2\2\2\u01a1\u01a4\3\2\2\2\u01a2\u01a0\3\2\2"+
		"\2\u01a2\u01a3\3\2\2\2\u01a3\u01a5\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a5\u01a8"+
		"\7M\2\2\u01a6\u01a7\7F\2\2\u01a7\u01a9\5L\'\2\u01a8\u01a6\3\2\2\2\u01a8"+
		"\u01a9\3\2\2\2\u01a9O\3\2\2\2\u01aa\u01ab\7H\2\2\u01ab\u01ac\5R*\2\u01ac"+
		"Q\3\2\2\2\u01ad\u01b9\5T+\2\u01ae\u01b9\5V,\2\u01af\u01b9\5X-\2\u01b0"+
		"\u01b9\5Z.\2\u01b1\u01b9\5\\/\2\u01b2\u01b9\5^\60\2\u01b3\u01b9\5`\61"+
		"\2\u01b4\u01b9\5b\62\2\u01b5\u01b9\5d\63\2\u01b6\u01b9\5f\64\2\u01b7\u01b9"+
		"\5h\65\2\u01b8\u01ad\3\2\2\2\u01b8\u01ae\3\2\2\2\u01b8\u01af\3\2\2\2\u01b8"+
		"\u01b0\3\2\2\2\u01b8\u01b1\3\2\2\2\u01b8\u01b2\3\2\2\2\u01b8\u01b3\3\2"+
		"\2\2\u01b8\u01b4\3\2\2\2\u01b8\u01b5\3\2\2\2\u01b8\u01b6\3\2\2\2\u01b8"+
		"\u01b7\3\2\2\2\u01b9S\3\2\2\2\u01ba\u01bb\7;\2\2\u01bb\u01bc\7L\2\2\u01bc"+
		"\u01bd\7\35\2\2\u01bd\u01be\7M\2\2\u01beU\3\2\2\2\u01bf\u01c0\7@\2\2\u01c0"+
		"\u01c1\7L\2\2\u01c1\u01c2\7\35\2\2\u01c2\u01c3\7M\2\2\u01c3W\3\2\2\2\u01c4"+
		"\u01c5\7<\2\2\u01c5Y\3\2\2\2\u01c6\u01c7\7=\2\2\u01c7\u01c8\7L\2\2\u01c8"+
		"\u01c9\7\35\2\2\u01c9\u01ca\7F\2\2\u01ca\u01cd\7\35\2\2\u01cb\u01cc\7"+
		"F\2\2\u01cc\u01ce\7\35\2\2\u01cd\u01cb\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce"+
		"\u01cf\3\2\2\2\u01cf\u01d0\7M\2\2\u01d0[\3\2\2\2\u01d1\u01d2\7?\2\2\u01d2"+
		"\u01d3\7L\2\2\u01d3\u01d4\7\35\2\2\u01d4\u01d5\7F\2\2\u01d5\u01d6\7\35"+
		"\2\2\u01d6\u01d7\7M\2\2\u01d7]\3\2\2\2\u01d8\u01d9\7>\2\2\u01d9_\3\2\2"+
		"\2\u01da\u01db\7:\2\2\u01db\u01dc\7L\2\2\u01dc\u01df\7\35\2\2\u01dd\u01de"+
		"\7F\2\2\u01de\u01e0\7\35\2\2\u01df\u01dd\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0"+
		"\u01e1\3\2\2\2\u01e1\u01e2\7M\2\2\u01e2a\3\2\2\2\u01e3\u01e4\7A\2\2\u01e4"+
		"\u01e5\7L\2\2\u01e5\u01e6\7\35\2\2\u01e6\u01e7\7M\2\2\u01e7c\3\2\2\2\u01e8"+
		"\u01e9\79\2\2\u01e9e\3\2\2\2\u01ea\u01eb\7B\2\2\u01eb\u01ec\7L\2\2\u01ec"+
		"\u01ed\5R*\2\u01ed\u01ee\7F\2\2\u01ee\u01ef\7\35\2\2\u01ef\u01f0\7M\2"+
		"\2\u01f0g\3\2\2\2\u01f1\u01f2\7C\2\2\u01f2\u01f3\7L\2\2\u01f3\u01f4\5"+
		"R*\2\u01f4\u01f5\7F\2\2\u01f5\u01fa\7H\2\2\u01f6\u01f7\7F\2\2\u01f7\u01f9"+
		"\7H\2\2\u01f8\u01f6\3\2\2\2\u01f9\u01fc\3\2\2\2\u01fa\u01f8\3\2\2\2\u01fa"+
		"\u01fb\3\2\2\2\u01fb\u01fd\3\2\2\2\u01fc\u01fa\3\2\2\2\u01fd\u01fe\7M"+
		"\2\2\u01fei\3\2\2\2\u01ff\u0200\7\63\2\2\u0200\u0201\78\2\2\u0201\u0202"+
		"\7H\2\2\u0202\u0203\5l\67\2\u0203k\3\2\2\2\u0204\u0205\7\65\2\2\u0205"+
		"\u020d\5P)\2\u0206\u0207\7\64\2\2\u0207\u020d\7H\2\2\u0208\u0209\7\63"+
		"\2\2\u0209\u020a\7H\2\2\u020a\u020d\5P)\2\u020b\u020d\5L\'\2\u020c\u0204"+
		"\3\2\2\2\u020c\u0206\3\2\2\2\u020c\u0208\3\2\2\2\u020c\u020b\3\2\2\2\u020d"+
		"m\3\2\2\2\60t|\u0086\u0094\u0098\u009b\u00a3\u00ac\u00b1\u00bf\u00ce\u00d5"+
		"\u00ea\u00ee\u00f7\u00ff\u0109\u0110\u0118\u011b\u011e\u0121\u0124\u0127"+
		"\u012e\u013a\u0142\u0145\u014f\u0153\u0159\u0163\u016c\u0171\u017f\u0184"+
		"\u0187\u018e\u0191\u01a2\u01a8\u01b8\u01cd\u01df\u01fa\u020c";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}